This reverts commit 33406cf. It
introduces memory leaks:

Direct leak of 24 byte(s) in 1 object(s) allocated from:
    #0 0x7fb773b389d7 in operator new(unsigned long) (/lib64/libasan.so.5+0x10f9d7)
    ceph#1 0x108f0d4 in seastar::reactor::poller::~poller() ../src/core/reactor.cc:2879
    ceph#2 0x11c1e59 in std::experimental::fundamentals_v1::_Optional_base<seastar::reactor::poller, true>::~_Optional_base() /usr/include/c++/9/experimental/optional:288
    ceph#3 0x118f2d7 in std::experimental::fundamentals_v1::optional<seastar::reactor::poller>::~optional() /usr/include/c++/9/experimental/optional:491
    ceph#4 0x108c5a5 in seastar::reactor::run() ../src/core/reactor.cc:2587
    ceph#5 0xf1a822 in seastar::app_template::run_deprecated(int, char**, std::function<void ()>&&) ../src/core/app-template.cc:199
    ceph#6 0xf1885d in seastar::app_template::run(int, char**, std::function<seastar::future<int> ()>&&) ../src/core/app-template.cc:115
    ceph#7 0xeb2735 in operator() ../src/testing/test_runner.cc:72
    ceph#8 0xebb342 in _M_invoke /usr/include/c++/9/bits/std_function.h:300
    ceph#9 0xf3d8b0 in std::function<void ()>::operator()() const /usr/include/c++/9/bits/std_function.h:690
    ceph#10 0x1034c72 in seastar::posix_thread::start_routine(void*) ../src/core/posix.cc:52
    ceph#11 0x7fb7738804e1 in start_thread /usr/src/debug/glibc-2.30-13-g919af705ee/nptl/pthread_create.c:479

Reported-by: Rafael Avila de Espindola <espindola@scylladb.com>

"
This series enhances seastar backtraces to contain information not only about
current task's call stack, but also information about tasks which are blocked
on the current task.

For example, when a thread is waiting for I/O operation to complete, the
continuation chain will contain the continuation which handles ready I/O, then
a continuation which wakes the thread, then the continuation which waits for
the thread to finish. This gives much more context in the backtrace, similar
to the one we would get in a synchronous programming model.

Presenting only current backtrace of the reactor thread is in many
cases not enough.

This is how extended backtraces will be logged:

INFO  2020-05-06 11:39:32,362 [shard 0] seastar - backtrace:    0x5b7ed9
   0x5b80e2
   0x5b8599
   0x437d76
   0x43e88b
   0x4c9617
   0x4c990d
   0x4f65c5
   0x4a962c
   0x4aa245
   0x49e785
   0x4c288d
   /lib64/libpthread.so.0+0x94e1
   /lib64/libc.so.6+0x1016a2
   --------
   seastar::continuation<seastar::internal::promise_base_with_type<>, seastar::future<>::then_impl_nrvo<func4()::{lambda()#1}, seastar::future<> >(func4()::{lambda()#1}&&)::{lambda()#1}::operator()() const::{lambda(seastar::internal::promise_base_with_type<>&, seastar::future_state<>&&)#1}>
   --------
   seastar::future<>::thread_wake_task

The --- separator separates backtraces of different tasks in the chain.

A side benefit of the series is that all backtraces will now some meaningful
information in them (current continuation name) without the need to resolve addresses.

Another use case is heap profiles. Currently measuring memory
allocations for one large operation is hard if it starts many
allocating continuations. Tasks for those continuations will
be spread in the profile and not correlated with the grand
operation. Backtracing across tasks solves that because different
paths are joined by a common base.

The task class is extended with a virtual method:

   virtual task* waiting_task() noexcept = 0;

which allows one to walk the continuation chain. It returns the next task
blocked on the current one.

When backtrace is collected, for each task its type_info is pushed,
which allows us to obtain the name of the continuation.

Optionally, when the build is configured with --enable-task-backtrace, full backtrace
is attached to continuation tasks when they're created (at deferring points)
so that we get more context.

No regression showed by perf_simple_query (@ 120k tps).
"

* tag 'backtracing-across-tasks-v5.1' of github.com:tgrabiec/seastar:
  util/backtrace: Cache hash of the backtrace
  core/task, util/backtrace: Allow capturing backtrace at preemption points
  core/memory: Move disable_backtrace_temporarily declaration to the header
  tests: future: Add backtracing test
  addr2line: Ignore separator lines
  core/task, util/backtrace: Collect backtraces across continuation chains
  util/backtrace: Extract operator<<(std::ostream&, frame&)
  core/make_task: Implement lambda_task::waiting_task()
  core/task: Store promise inside lambda_task
  core/task: Extrack make_task() to a separate header
  core/reactor: Expose a pointer to currently running task
  core/future: Add ability to walk continuation chains
  util/backtrace: Capture current scheduling group in the backtrace

The iotune tool measures disk throughput and IOPS by doing four
sequential measurements:

1. sequentially writes into a big file
2. sequentially reads from the same file
3. randomly writes into this file again
4. randomly reads from, you know, the File

It's improtant that the measurement #1 comes first. On start
the test file is created and truncated to its size and this
first measurement fills it with data which is then read by steps
2 and 4. Respectively, after the 1st measurement the size of
the file should be updated to reflect the real amount of data
written into it.

The latter is done by taking the number of bytes written into
file. But in reality the first test may wrap around the initial
file size and re-write some data into it. After this the file
size can be seen bigger than it actually is, even times bigger.

Subsequently, the next tests will go and read from/write to
random holes in this area. For reading tests this becomes quite
problematic as the kernel will not submit real IO requess for
reads from missing (due to holes) blocks. As a result, the shown
bandwidth and IOPS will be some average value of disk IOPS and
kernel "reads-from-holes-per-second".

Fix this by getting the maximum position at which the first test
writes and limiting the next tests with this value, instead of
the amount of (over-)writter bytes.

Signed-off-by: Pavel Emelyanov <xemul@scylladb.com>
Message-Id: <20200623185120.17694-1-xemul@scylladb.com>

…o_with

Fixes failures in debug mode:
```
$ build/debug/tests/unit/closeable_test -l all -t deferred_close_test
WARNING: debug mode. Not for benchmarking or production
random-seed=3064133628
Running 1 test case...
Entering test module "../../tests/unit/closeable_test.cc"
../../tests/unit/closeable_test.cc(0): Entering test case "deferred_close_test"
../../src/testing/seastar_test.cc(43): info: check true has passed
==9449==WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false positives in some cases!
terminate called after throwing an instance of 'seastar::broken_promise'
  what():  broken promise
==9449==WARNING: ASan is ignoring requested __asan_handle_no_return: stack top: 0x7fbf1f49f000; bottom 0x7fbf40971000; size: 0xffffffffdeb2e000 (-558702592)
False positive error reports may follow
For details see google/sanitizers#189
=================================================================
==9449==AddressSanitizer CHECK failed: ../../../../libsanitizer/asan/asan_thread.cpp:356 "((ptr[0] == kCurrentStackFrameMagic)) != (0)" (0x0, 0x0)
    #0 0x7fbf45f39d0b  (/lib64/libasan.so.6+0xb3d0b)
    #1 0x7fbf45f57d4e  (/lib64/libasan.so.6+0xd1d4e)
    #2 0x7fbf45f3e724  (/lib64/libasan.so.6+0xb8724)
    #3 0x7fbf45eb3e5b  (/lib64/libasan.so.6+0x2de5b)
    #4 0x7fbf45eb51e8  (/lib64/libasan.so.6+0x2f1e8)
    #5 0x7fbf45eb7694  (/lib64/libasan.so.6+0x31694)
    #6 0x7fbf45f39398  (/lib64/libasan.so.6+0xb3398)
    #7 0x7fbf45f3a00b in __asan_report_load8 (/lib64/libasan.so.6+0xb400b)
    #8 0xfe6d52 in bool __gnu_cxx::operator!=<dl_phdr_info*, std::vector<dl_phdr_info, std::allocator<dl_phdr_info> > >(__gnu_cxx::__normal_iterator<dl_phdr_info*, std::vector<dl_phdr_info, std::allocator<dl_phdr_info> > > const&, __gnu_cxx::__normal_iterator<dl_phdr_info*, std::vector<dl_phdr_info, std::allocator<dl_phdr_info> > > const&) /usr/include/c++/10/bits/stl_iterator.h:1116
    #9 0xfe615c in dl_iterate_phdr ../../src/core/exception_hacks.cc:121
    #10 0x7fbf44bd1810 in _Unwind_Find_FDE (/lib64/libgcc_s.so.1+0x13810)
    #11 0x7fbf44bcd897  (/lib64/libgcc_s.so.1+0xf897)
    #12 0x7fbf44bcea5f  (/lib64/libgcc_s.so.1+0x10a5f)
    #13 0x7fbf44bcefd8 in _Unwind_RaiseException (/lib64/libgcc_s.so.1+0x10fd8)
    #14 0xfe6281 in _Unwind_RaiseException ../../src/core/exception_hacks.cc:148
    scylladb#15 0x7fbf457364bb in __cxa_throw (/lib64/libstdc++.so.6+0xaa4bb)
    scylladb#16 0x7fbf45e10a21  (/lib64/libboost_unit_test_framework.so.1.73.0+0x1aa21)
    scylladb#17 0x7fbf45e20fe0 in boost::execution_monitor::execute(boost::function<int ()> const&) (/lib64/libboost_unit_test_framework.so.1.73.0+0x2afe0)
    scylladb#18 0x7fbf45e21094 in boost::execution_monitor::vexecute(boost::function<void ()> const&) (/lib64/libboost_unit_test_framework.so.1.73.0+0x2b094)
    scylladb#19 0x7fbf45e43921 in boost::unit_test::unit_test_monitor_t::execute_and_translate(boost::function<void ()> const&, unsigned long) (/lib64/libboost_unit_test_framework.so.1.73.0+0x4d921)
    scylladb#20 0x7fbf45e5eae1  (/lib64/libboost_unit_test_framework.so.1.73.0+0x68ae1)
    scylladb#21 0x7fbf45e5ed31  (/lib64/libboost_unit_test_framework.so.1.73.0+0x68d31)
    scylladb#22 0x7fbf45e2e547 in boost::unit_test::framework::run(unsigned long, bool) (/lib64/libboost_unit_test_framework.so.1.73.0+0x38547)
    scylladb#23 0x7fbf45e43618 in boost::unit_test::unit_test_main(bool (*)(), int, char**) (/lib64/libboost_unit_test_framework.so.1.73.0+0x4d618)
    scylladb#24 0x44798d in seastar::testing::entry_point(int, char**) ../../src/testing/entry_point.cc:77
    scylladb#25 0x4134b5 in main ../../include/seastar/testing/seastar_test.hh:65
    scylladb#26 0x7fbf44a1b1e1 in __libc_start_main (/lib64/libc.so.6+0x281e1)
    scylladb#27 0x4133dd in _start (/home/bhalevy/dev/seastar/build/debug/tests/unit/closeable_test+0x4133dd)
```

Signed-off-by: Benny Halevy <bhalevy@scylladb.com>
Message-Id: <20210406100911.12278-1-bhalevy@scylladb.com>

This is step #1 in removing all classes manipulations API from
io_queue to io_priority_class.

Signed-off-by: Pavel Emelyanov <xemul@scylladb.com>

The io_queue_topology describes "numerical" topology -- the
numbers of queues and groups and their mappings to each other.
Later this info is materialized into device_io_topology by
creating vectors of queues and groups.

There's no real need in this split. The io_queue_topology can
just create the needed vectors with no objects in them, so
that later queues and groups are put into _it_ instead of on
the device_io_topology.

This is step #1 -- move vector of queues into io_queue_topology.

Signed-off-by: Pavel Emelyanov <xemul@scylladb.com>

This is a tiny leak fix -- if queues initialization fails in the
middle some allocated, but not yet assigned queues will not be
deleted.

(side note: this patch is the beneficiary of the explicit outline
constructors for io_queue_topology from patch #1 of this set)

Signed-off-by: Pavel Emelyanov <xemul@scylladb.com>

… enqueue_op throws

If enqueue_op fails to allocate, op_func ends up setting `fut`
error to broken promise and we get the following warning:
```
WARN  2021-09-20 11:02:33,437 [shard 0] seastar - Exceptional future ignored: seastar::broken_promise (broken promise), backtrace: 0x57a609 0x57a932 0x57ace9 0x488b57 0x488c7c 0x44a970 0x41418e 0x4645e9 0x47f99a 0x484dfb 0x485acc 0x44f6ef 0x44fcfb 0x45342d 0x4464f8 0x42a33c
```

Decoded:
```
seastar::append_challenged_posix_file_impl::write_dma(unsigned long, void const*, unsigned long, seastar::io_priority_class const&, seastar::io_intent*) [clone .cold] at /home/bhalevy/dev/seastar/build/release/../../src/core/file-impl.hh:258
 (inlined by) seastar::append_challenged_posix_file_impl::write_dma(unsigned long, void const*, unsigned long, seastar::io_priority_class const&, seastar::io_intent*) at /home/bhalevy/dev/seastar/build/release/../../src/core/file.cc:811
seastar::file::dma_write_impl(unsigned long, unsigned char const*, unsigned long, seastar::io_priority_class const&, seastar::io_intent*) at /home/bhalevy/dev/seastar/build/release/../../src/core/file.cc:1182
seastar::future<unsigned long> seastar::file::dma_write<char>(unsigned long, char const*, unsigned long, seastar::io_priority_class const&, seastar::io_intent*) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/file.hh:351
 (inlined by) seastar::file_data_sink_impl::do_put(unsigned long, seastar::temporary_buffer<char>) at /home/bhalevy/dev/seastar/build/release/../../src/core/fstream.cc:431
seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}::operator()() at /home/bhalevy/dev/seastar/build/release/../../src/core/fstream.cc:387
seastar::future<void> seastar::futurize<seastar::future<void> >::invoke<seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}>(seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}&&) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/future.hh:2135
 (inlined by) seastar::future<void> seastar::futurize<seastar::future<void> >::invoke<seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}>(seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}&&, seastar::internal::monostate) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/future.hh:1979
 (inlined by) seastar::future<void> seastar::future<void>::then_impl<seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}, seastar::future<void> >(seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}&&) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/future.hh:1601
 (inlined by) seastar::internal::future_result<seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}, void>::future_type seastar::internal::call_then_impl<seastar::future<void> >::run<seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}>(seastar::future<void>&, seastar::internal::future_result&&) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/future.hh:1234
 (inlined by) seastar::future<void> seastar::future<void>::then<seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}, seastar::future<void> >(seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>)::{lambda()#1}&&) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/future.hh:1520
 (inlined by) seastar::file_data_sink_impl::put(seastar::temporary_buffer<char>) at /home/bhalevy/dev/seastar/build/release/../../src/core/fstream.cc:406
seastar::data_sink::put(seastar::temporary_buffer<char>) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/iostream.hh:142
 (inlined by) seastar::output_stream<char>::put(seastar::temporary_buffer<char>) at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/iostream-impl.hh:454
seastar::output_stream<char>::flush() at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/iostream-impl.hh:420
seastar::output_stream<char>::close() at /home/bhalevy/dev/seastar/build/release/../../include/seastar/core/iostream-impl.hh:512
```

To prevent this, catch the error around enqueue_op and handle
it by fut.ignore_ready_future().

Signed-off-by: Benny Halevy <bhalevy@scylladb.com>

Some may contain space characters around the '+' operator in, e.g.:
```
    #1  0x00007fd2dab4f950 abort (libc.so.6 + 0x26950)
```

Fixes scylladb#1206

Signed-off-by: Benny Halevy <bhalevy@scylladb.com>

…es' from Benny Halevy

Some may contain space characters around the '+' operator in, e.g.:
```
    #1  0x00007fd2dab4f950 abort (libc.so.6 + 0x26950)
```

Fixes scylladb#1206

Signed-off-by: Benny Halevy <bhalevy@scylladb.com>

Closes scylladb#1207

* https://github.com/scylladb/seastar:
  seastar-addr2line: strip input lines
  seastar-addr2line: support more flexible syslog-style backtraces

When we enable the sanitizer, we get following error while running
iotune:

==86505==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 4096 byte(s) in 1 object(s) allocated from:
    #0 0x5701b8 in aligned_alloc (/home/syuu/seastar.2/build/sanitize/apps/iotune/iotune+0x5701b8) (BuildId: 411f9852d64ed8982d5b33d02489b5932d92b8b7)
    #1 0x6d0813 in seastar::filesystem_has_good_aio_support(seastar::basic_sstring<char, unsigned int, 15u, true>, bool) /home/syuu/seastar.2/src/core/fsqual.cc:74:16
    #2 0x5bcd0d in main::$_0::operator()() const::'lambda'()::operator()() const /home/syuu/seastar.2/apps/iotune/iotune.cc:742:21
    #3 0x5bb1f1 in seastar::future<int> seastar::futurize<int>::apply<main::$_0::operator()() const::'lambda'()>(main::$_0::operator()() const::'lambda'()&&, std::tuple<>&&) /home/syuu/seastar.2/include/seastar/core/future.hh:2118:28
    #4 0x5bb039 in seastar::futurize<std::invoke_result<main::$_0::operator()() const::'lambda'()>::type>::type seastar::async<main::$_0::operator()() const::'lambda'()>(seastar::thread_attributes, main::$_0::operator()() const::'lambda'()&&)::'lambda'()::operator()() const /home/syuu/seastar.2/include/seastar/core/thread.hh:258:13
    #5 0x5bb039 in seastar::noncopyable_function<void ()>::direct_vtable_for<seastar::futurize<std::invoke_result<main::$_0::operator()() const::'lambda'()>::type>::type seastar::async<main::$_0::operator()() const::'lambda'()>(seastar::thread_attributes, main::$_0::operator()() const::'lambda'()&&)::'lambda'()>::call(seastar::noncopyable_function<void ()> const*) /home/syuu/seastar.2/include/seastar/util/noncopyable_function.hh:124:20
    #6 0x8e0a77 in seastar::thread_context::main() /home/syuu/seastar.2/src/core/thread.cc:299:9
    #7 0x7f30ff8547bf  (/lib64/libc.so.6+0x547bf) (BuildId: 85c438f4ff93e21675ff174371c9c583dca00b2c)

SUMMARY: AddressSanitizer: 4096 byte(s) leaked in 1 allocation(s).

This is because we don't free buffer which allocated at filesystem_has_good_aio_support(), we should free it to avoid such error.

And this is needed to test Scylla machine image with debug mode binary,
since it tries to run iotune with the sanitizer and fails.

Closes scylladb#1284

this change is a follow-up of 338ba97.

before this change, ${CMAKE_CURRENT_BINARY_DIR} is used for
Seastar_BINARY_DIR. if Seastar is a top-level project, the values
of ${CMAKE_CURRENT_BINARY_DIR} and ${CMAKE_BINARY_DIR} are
identical. but if Seastar is embedded in a parent project,
${CMAKE_BINARY_DIR} would be somewhere like "bulid/seastar" where
"build" is the build directory of the parent project.
but we are still referencing the build directory with
${Seastar_BINARY_DIR} and issuing commands like

cmake --build ${Seastar_BINARY_DIR} --target ${target}

if this would fail as the build directory is not ${Seastar_BINARY_DIR}
anymore. if the cmake generator is make, the failure would look like:

> gmake: *** No rule to make target 'test_unit_abort_source_run'.  Stop.

if the cmake generator is ninja, the failure would look like:

> 1/95 Test  #1: Seastar.unit.abort_source .....................***Failed    0.02 sec
> ninja: error: loading 'build.ninja': No such file or directory

after this change, all occurrences of

cmake --build ${Seastar_BINARY_DIR}

are changed to

cmake --build ${CMAKE_BINARY_DIR}

this ensure that these commands can find the build directory
at the top level of the build tree.

Signed-off-by: Kefu Chai <tchaikov@gmail.com>

in main(), we creates an instance of `http_server_control` using
new, but we never destroy it. this is identified by ASan

```
==2190125==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 8 byte(s) in 1 object(s) allocated from:
    #0 0x55e21cf487bd in operator new(unsigned long) /home/kefu/dev/llvm-project/compiler-rt/lib/asan/asan_new_delete.cpp:86:3
    #1 0x55e21cf6cf31 in main::$_0::operator()() const::'lambda'()::operator()() const /home/kefu/dev/seastar/apps/httpd/main.cc:121:27
    #2 0x55e21cf6b4cc in int std::__invoke_impl<int, main::$_0::operator()() const::'lambda'()>(std::__invoke_other, main::$_0::operator()() const::'lambda'()&&) /usr/lib/gcc/x86_64-redhat-linux/14/../../../../incl
ude/c++/14/bits/invoke.h:61:14
    #3 0x55e21cf6b46c in std::__invoke_result<main::$_0::operator()() const::'lambda'()>::type std::__invoke<main::$_0::operator()() const::'lambda'()>(main::$_0::operator()() const::'lambda'()&&) /usr/lib/gcc/x86_
64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h:96:14
    #4 0x55e21cf6b410 in decltype(auto) std::__apply_impl<main::$_0::operator()() const::'lambda'(), std::tuple<>>(main::$_0::operator()() const::'lambda'()&&, std::tuple<>&&, std::integer_sequence<unsigned long, .
..>) /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple:2921:14
    #5 0x55e21cf6b3b2 in decltype(auto) std::apply<main::$_0::operator()() const::'lambda'(), std::tuple<>>(main::$_0::operator()() const::'lambda'()&&, std::tuple<>&&) /usr/lib/gcc/x86_64-redhat-linux/14/../../../
../include/c++/14/tuple:2936:14
    #6 0x55e21cf6b283 in seastar::future<int> seastar::futurize<int>::apply<main::$_0::operator()() const::'lambda'()>(main::$_0::operator()() const::'lambda'()&&, std::tuple<>&&) /home/kefu/dev/seastar/include/sea
star/core/future.hh:2005:28
    #7 0x55e21cf6b043 in seastar::futurize<std::invoke_result<main::$_0::operator()() const::'lambda'()>::type>::type seastar::async<main::$_0::operator()() const::'lambda'()>(seastar::thread_attributes, main::$_0:
:operator()() const::'lambda'()&&)::'lambda'()::operator()() const /home/kefu/dev/seastar/include/seastar/core/thread.hh:260:13
    #8 0x55e21cf6ae74 in seastar::noncopyable_function<void ()>::direct_vtable_for<seastar::futurize<std::invoke_result<main::$_0::operator()() const::'lambda'()>::type>::type seastar::async<main::$_0::operator()()
 const::'lambda'()>(seastar::thread_attributes, main::$_0::operator()() const::'lambda'()&&)::'lambda'()>::call(seastar::noncopyable_function<void ()> const*) /home/kefu/dev/seastar/include/seastar/util/noncopyable
_function.hh:129:20
    #9 0x7f5d757a0fb3 in seastar::noncopyable_function<void ()>::operator()() const /home/kefu/dev/seastar/include/seastar/util/noncopyable_function.hh:215:16
    #10 0x7f5d75ef5611 in seastar::thread_context::main() /home/kefu/dev/seastar/src/core/thread.cc:311:9
    #11 0x7f5d75ef50eb in seastar::thread_context::s_main(int, int) /home/kefu/dev/seastar/src/core/thread.cc:287:43
    #12 0x7f5d72f8a18f  (/lib64/libc.so.6+0x5a18f) (BuildId: b098f1c75a76548bb230d8f551eae07a2aeccf06)
```

so, in this change, let's hold it using a smart pointer, so we
can destroy it when it leaves the lexical scope.

Signed-off-by: Kefu Chai <kefu.chai@scylladb.com>

Closes scylladb#2224